home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / y2l.lha / y2l / Parser.c < prev    next >
C/C++ Source or Header  |  1992-08-20  |  28KB  |  1,160 lines
  1. /* $Id: Parser.c,v 2.9 1992/08/07 15:28:42 grosch rel $ */
  2.  
  3. # define bool        char
  4. # define true        1
  5. # define false        0
  6.  
  7. # include "Parser.h"
  8. # include "Errors.h"
  9.  
  10. # ifdef __cplusplus
  11. extern "C" {
  12. #    include "Memory.h"
  13. #    include "DynArray.h"
  14. #    include "Sets.h"
  15. #    ifndef BCOPY
  16. #       include <memory.h>
  17. #    endif
  18. }
  19. # else
  20. #    include "Memory.h"
  21. #    include "DynArray.h"
  22. #    include "Sets.h"
  23. #    ifndef BCOPY
  24. #       include <memory.h>
  25. #    endif
  26. # endif
  27.  
  28. # if defined __STDC__ | defined __cplusplus
  29. # define ARGS(parameters)    parameters
  30. # else
  31. # define ARGS(parameters)    ()
  32. # endif
  33.  
  34. # ifdef lex_interface
  35. #    define GetToken    yylex
  36.      extern int yylex ();
  37. #    ifndef AttributeDef
  38. #    include "Positions.h"
  39.         typedef struct { tPosition Position; } tScanAttribute;
  40.         static    tScanAttribute    Attribute = {{ 0, 0 }};
  41. #    endif
  42. #    ifndef ErrorAttributeDef
  43. #    define ErrorAttribute(Token, RepairAttribute)
  44. #    endif
  45. #    ifndef yyGetAttribute
  46. #    define yyGetAttribute(yyAttrStackPtr, Attribute) * yyAttrStackPtr = yylval
  47. #    endif
  48. # else
  49. #    include "Scanner.h"
  50. #    ifndef yyGetAttribute
  51. #    define yyGetAttribute(yyAttrStackPtr, Attribute) (yyAttrStackPtr)->Scan = Attribute
  52. #    endif
  53. # endif
  54.  
  55. /* line 2 "/tmp/lalr15895" */
  56. /* line 1 "yacc.lalr" */
  57.  
  58. typedef union { tScanAttribute Scan; } tParsAttribute;
  59.  
  60. int rword;        /* 0 = %token, 1 = %oper, 2 = %type */
  61. tStringRef lhs, tag, prec;
  62. tStringRef left_str, right_str, none_str, colon_str, bar_str, action_str, prec_str, dot_str;
  63. int has_rhs, has_action;
  64. struct tCell default_action = { 0, 0 };
  65.  
  66.  
  67. # if defined lex_interface & ! defined yylvalDef
  68.      tParsAttribute yylval;
  69. # endif
  70.  
  71. # ifndef yyInitStackSize
  72. #    define yyInitStackSize    100
  73. # endif
  74. # define yyNoState        0
  75.  
  76. # define yyFirstTerminal    0
  77. # define yyLastTerminal        20
  78. # define yyTableMax        138
  79. # define yyNTableMax        54
  80. # define yyFirstReadState    1
  81. # define yyLastReadState    32
  82. # define yyFirstReadTermState    33
  83. # define yyLastReadTermState    45
  84. # define yyLastReadNontermState    53
  85. # define yyFirstReduceState    54
  86. # define yyLastReduceState    91
  87. # define yyStartState        1
  88. # define yyStopState        54
  89.  
  90. # define yyFirstFinalState    yyFirstReadTermState
  91.  
  92. typedef unsigned short    yyStateRange    ;
  93. typedef unsigned short    yySymbolRange    ;
  94. typedef struct    { yyStateRange Check, Next; } yyTCombType ;
  95.  
  96.     char *        Parser_TokenName    [yyLastTerminal + 1] = {
  97. "_EndOfFile",
  98. "identifier",
  99. "C_IDENT",
  100. "number",
  101. "%left",
  102. "%right",
  103. "%nonassoc",
  104. "%token",
  105. "%prec",
  106. "%type",
  107. "%start",
  108. "%union",
  109. "%%",
  110. "<",
  111. ">",
  112. ",",
  113. "|",
  114. "{",
  115. "}",
  116. ";",
  117. ":",
  118. };
  119. static    yyTCombType    yyTComb        [yyTableMax + 1] = {
  120. {32, 54},
  121. {3, 38},
  122. {4, 59},
  123. {5, 6},
  124. {1, 60},
  125. {1, 60},
  126. {1, 60},
  127. {1, 60},
  128. {10, 11},
  129. {1, 60},
  130. {1, 60},
  131. {1, 60},
  132. {1, 60},
  133. {2, 33},
  134. {2, 34},
  135. {2, 35},
  136. {2, 36},
  137. {24, 56},
  138. {2, 37},
  139. {2, 3},
  140. {2, 39},
  141. {2, 4},
  142. {6, 79},
  143. {7, 8},
  144. {11, 88},
  145. {12, 41},
  146. {11, 88},
  147. {15, 83},
  148. {16, 17},
  149. {24, 43},
  150. {13, 77},
  151. {26, 27},
  152. {13, 77},
  153. {14, 58},
  154. {27, 44},
  155. {14, 15},
  156. {11, 88},
  157. {28, 29},
  158. {0, 0},
  159. {0, 0},
  160. {11, 88},
  161. {11, 12},
  162. {13, 77},
  163. {11, 88},
  164. {25, 71},
  165. {14, 58},
  166. {13, 77},
  167. {0, 0},
  168. {19, 80},
  169. {14, 20},
  170. {19, 80},
  171. {20, 82},
  172. {20, 82},
  173. {20, 82},
  174. {0, 0},
  175. {0, 0},
  176. {25, 26},
  177. {0, 0},
  178. {0, 0},
  179. {20, 82},
  180. {19, 80},
  181. {0, 0},
  182. {0, 0},
  183. {20, 82},
  184. {19, 80},
  185. {0, 0},
  186. {0, 0},
  187. {20, 82},
  188. {20, 82},
  189. {0, 0},
  190. {20, 82},
  191. {21, 86},
  192. {21, 86},
  193. {21, 86},
  194. {0, 0},
  195. {0, 0},
  196. {0, 0},
  197. {0, 0},
  198. {0, 0},
  199. {21, 86},
  200. {0, 0},
  201. {0, 0},
  202. {0, 0},
  203. {21, 86},
  204. {22, 91},
  205. {22, 40},
  206. {22, 91},
  207. {21, 86},
  208. {21, 86},
  209. {23, 81},
  210. {21, 86},
  211. {23, 81},
  212. {22, 10},
  213. {0, 0},
  214. {0, 0},
  215. {0, 0},
  216. {22, 91},
  217. {0, 0},
  218. {0, 0},
  219. {0, 0},
  220. {22, 91},
  221. {23, 81},
  222. {0, 0},
  223. {22, 91},
  224. {0, 0},
  225. {23, 81},
  226. {0, 0},
  227. {29, 75},
  228. {23, 42},
  229. {29, 45},
  230. {29, 75},
  231. {29, 75},
  232. {29, 75},
  233. {29, 75},
  234. {0, 0},
  235. {29, 75},
  236. {29, 75},
  237. {29, 75},
  238. {29, 75},
  239. {0, 0},
  240. {0, 0},
  241. {29, 75},
  242. {30, 64},
  243. {30, 64},
  244. {30, 64},
  245. {30, 64},
  246. {0, 0},
  247. {30, 64},
  248. {30, 64},
  249. {30, 64},
  250. {30, 64},
  251. {0, 0},
  252. {0, 0},
  253. {30, 31},
  254. {0, 0},
  255. {0, 0},
  256. {0, 0},
  257. {0, 0},
  258. {0, 0},
  259. };
  260. static    unsigned short    yyNComb        [yyNTableMax - yyLastTerminal] = {
  261. 2,
  262. 5,
  263. 14,
  264. 24,
  265. 48,
  266. 32,
  267. 50,
  268. 25,
  269. 28,
  270. 30,
  271. 53,
  272. 7,
  273. 9,
  274. 13,
  275. 49,
  276. 16,
  277. 18,
  278. 47,
  279. 46,
  280. 19,
  281. 21,
  282. 22,
  283. 23,
  284. 47,
  285. 52,
  286. 51,
  287. 47,
  288. 0,
  289. 0,
  290. 0,
  291. 0,
  292. 0,
  293. 0,
  294. 0,
  295. };
  296. static    yyTCombType *    yyTBasePtr    [yyLastReadState + 1] = {
  297. & yyTComb [0],
  298. & yyTComb [0],
  299. & yyTComb [9],
  300. & yyTComb [0],
  301. & yyTComb [0],
  302. & yyTComb [1],
  303. & yyTComb [2],
  304. & yyTComb [3],
  305. & yyTComb [0],
  306. & yyTComb [0],
  307. & yyTComb [7],
  308. & yyTComb [24],
  309. & yyTComb [7],
  310. & yyTComb [30],
  311. & yyTComb [33],
  312. & yyTComb [7],
  313. & yyTComb [8],
  314. & yyTComb [0],
  315. & yyTComb [0],
  316. & yyTComb [48],
  317. & yyTComb [51],
  318. & yyTComb [71],
  319. & yyTComb [84],
  320. & yyTComb [89],
  321. & yyTComb [17],
  322. & yyTComb [43],
  323. & yyTComb [30],
  324. & yyTComb [20],
  325. & yyTComb [36],
  326. & yyTComb [106],
  327. & yyTComb [118],
  328. & yyTComb [0],
  329. & yyTComb [0],
  330. };
  331. static    unsigned short*    yyNBasePtr    [yyLastReadState + 1] = {
  332. & yyNComb [-21],
  333. & yyNComb [-21],
  334. & yyNComb [-21],
  335. & yyNComb [-21],
  336. & yyNComb [-21],
  337. & yyNComb [-21],
  338. & yyNComb [-21],
  339. & yyNComb [-21],
  340. & yyNComb [-21],
  341. & yyNComb [-21],
  342. & yyNComb [-21],
  343. & yyNComb [-20],
  344. & yyNComb [-21],
  345. & yyNComb [-21],
  346. & yyNComb [-21],
  347. & yyNComb [-21],
  348. & yyNComb [-21],
  349. & yyNComb [-17],
  350. & yyNComb [-15],
  351. & yyNComb [-21],
  352. & yyNComb [-17],
  353. & yyNComb [-12],
  354. & yyNComb [-12],
  355. & yyNComb [-21],
  356. & yyNComb [-21],
  357. & yyNComb [-21],
  358. & yyNComb [-21],
  359. & yyNComb [-21],
  360. & yyNComb [-21],
  361. & yyNComb [-21],
  362. & yyNComb [-7],
  363. & yyNComb [-6],
  364. & yyNComb [-21],
  365. };
  366. static    unsigned short    yyDefault    [yyLastReadState + 1] = {
  367. 0,
  368. 0,
  369. 0,
  370. 0,
  371. 0,
  372. 0,
  373. 0,
  374. 0,
  375. 21,
  376. 22,
  377. 0,
  378. 0,
  379. 0,
  380. 23,
  381. 0,
  382. 0,
  383. 0,
  384. 21,
  385. 22,
  386. 23,
  387. 0,
  388. 0,
  389. 11,
  390. 0,
  391. 0,
  392. 0,
  393. 0,
  394. 0,
  395. 0,
  396. 0,
  397. 28,
  398. 28,
  399. 0,
  400. };
  401. static    unsigned char    yyLength    [yyLastReduceState - yyFirstReduceState + 1] = {
  402. 2,
  403. 6,
  404. 0,
  405. 1,
  406. 0,
  407. 0,
  408. 0,
  409. 2,
  410. 2,
  411. 1,
  412. 3,
  413. 1,
  414. 1,
  415. 1,
  416. 1,
  417. 1,
  418. 3,
  419. 0,
  420. 1,
  421. 2,
  422. 3,
  423. 1,
  424. 2,
  425. 5,
  426. 2,
  427. 0,
  428. 5,
  429. 4,
  430. 0,
  431. 0,
  432. 2,
  433. 2,
  434. 0,
  435. 2,
  436. 2,
  437. 3,
  438. 2,
  439. 0,
  440. };
  441. static    yySymbolRange    yyLeftHandSide    [yyLastReduceState - yyFirstReduceState + 1] = {
  442. 39,
  443. 26,
  444. 25,
  445. 25,
  446. 24,
  447. 22,
  448. 21,
  449. 21,
  450. 27,
  451. 27,
  452. 27,
  453. 28,
  454. 28,
  455. 28,
  456. 28,
  457. 28,
  458. 29,
  459. 29,
  460. 30,
  461. 30,
  462. 30,
  463. 31,
  464. 31,
  465. 23,
  466. 23,
  467. 32,
  468. 35,
  469. 35,
  470. 37,
  471. 36,
  472. 33,
  473. 33,
  474. 33,
  475. 38,
  476. 34,
  477. 34,
  478. 34,
  479. 34,
  480. };
  481. static    yySymbolRange    yyContinuation    [yyLastReadState + 1] = {
  482. 0,
  483. 4,
  484. 12,
  485. 1,
  486. 2,
  487. 2,
  488. 20,
  489. 20,
  490. 0,
  491. 0,
  492. 1,
  493. 0,
  494. 18,
  495. 0,
  496. 0,
  497. 20,
  498. 20,
  499. 0,
  500. 0,
  501. 0,
  502. 0,
  503. 0,
  504. 0,
  505. 0,
  506. 0,
  507. 1,
  508. 1,
  509. 14,
  510. 1,
  511. 1,
  512. 4,
  513. 1,
  514. 0,
  515. };
  516. static    unsigned short    yyFinalToProd    [yyLastReadNontermState - yyFirstReadTermState + 1] = {
  517. 66,
  518. 67,
  519. 68,
  520. 65,
  521. 69,
  522. 62,
  523. 63,
  524. 84,
  525. 87,
  526. 90,
  527. 57,
  528. 70,
  529. 76,
  530. 89,
  531. 85,
  532. 55,
  533. 78,
  534. 61,
  535. 74,
  536. 73,
  537. 72,
  538. };
  539.  
  540. static    void    yyErrorRecovery        ARGS((yySymbolRange * yyTerminal, yyStateRange * yyStateStack, unsigned long yyStackSize, short yyStackPtr));
  541. static    void    yyComputeContinuation    ARGS((yyStateRange * yyStack, unsigned long yyStackSize, short yyStackPtr, tSet * yyContinueSet));
  542. static    bool    yyIsContinuation    ARGS((yySymbolRange yyTerminal, yyStateRange * yyStateStack, unsigned long yyStackSize, short yyStackPtr));
  543. static    void    yyComputeRestartPoints    ARGS((yyStateRange * yyStateStack, unsigned long yyStackSize, short yyStackPtr, tSet * yyRestartSet));
  544. static    yyStateRange yyNext        ARGS((yyStateRange yyState, yySymbolRange yySymbol));
  545. static    void    BeginParser        ();
  546.  
  547. int Parser ()
  548.    {
  549.       register    yyStateRange    yyState        ;
  550.       register    long        yyTerminal    ;
  551.       register    yyStateRange *    yyStateStackPtr ;
  552.       register    tParsAttribute *yyAttrStackPtr    ;
  553.       register    bool        yyIsRepairing    ;
  554.         unsigned long    yyStateStackSize= yyInitStackSize;
  555.         unsigned long    yyAttrStackSize = yyInitStackSize;
  556.         yyStateRange *    yyStateStack    ;
  557.         tParsAttribute* yyAttributeStack;
  558.         tParsAttribute    yySynAttribute    ;    /* synthesized attribute */
  559.       register    yyStateRange *    yyEndOfStack    ;
  560.         int        yyErrorCount    = 0;
  561.    
  562.  
  563.  
  564.       BeginParser ();
  565.       yyState        = yyStartState;
  566.       yyTerminal    = GetToken ();
  567.       MakeArray ((char * *) & yyStateStack, & yyStateStackSize, sizeof (yyStateRange));
  568.       MakeArray ((char * *) & yyAttributeStack, & yyAttrStackSize, sizeof (tParsAttribute));
  569.       yyEndOfStack    = & yyStateStack [yyStateStackSize];
  570.       yyStateStackPtr    = yyStateStack;
  571.       yyAttrStackPtr    = yyAttributeStack;
  572.       yyIsRepairing    = false;
  573.  
  574.    ParseLoop:
  575.       for (;;) {
  576.      if (yyStateStackPtr >= yyEndOfStack) {
  577.         int yyyStateStackPtr= yyStateStackPtr - yyStateStack;
  578.         int yyyAttrStackPtr    = yyAttrStackPtr - yyAttributeStack;
  579.         ExtendArray ((char * *) & yyStateStack, & yyStateStackSize, sizeof (yyStateRange));
  580.         ExtendArray ((char * *) & yyAttributeStack, & yyAttrStackSize, sizeof (tParsAttribute));
  581.         yyStateStackPtr    = yyStateStack + yyyStateStackPtr;
  582.         yyAttrStackPtr    = yyAttributeStack + yyyAttrStackPtr;
  583.         yyEndOfStack    = & yyStateStack [yyStateStackSize];
  584.      }
  585.      * yyStateStackPtr = yyState;
  586.  
  587.    TermTrans:
  588.      for (;;) {    /* SPEC State = Next (State, Terminal); terminal transition */
  589.         register short * yyTCombPtr;
  590.  
  591.         yyTCombPtr = (short *) (yyTBasePtr [yyState] + yyTerminal);
  592.         if (* yyTCombPtr ++ == yyState) { yyState = * yyTCombPtr; break; }
  593.         if ((yyState = yyDefault [yyState]) != yyNoState) goto TermTrans;
  594.  
  595.                             /* syntax error */
  596.         if (! yyIsRepairing) {            /* report and recover */
  597.            yySymbolRange yyyTerminal = yyTerminal;
  598.  
  599.            yyErrorCount ++;
  600.            yyErrorRecovery (& yyyTerminal, yyStateStack, yyStateStackSize, yyStateStackPtr - yyStateStack);
  601.            yyTerminal = yyyTerminal;
  602.            yyIsRepairing = true;
  603.         }
  604.         yyState = * yyStateStackPtr;
  605.         for (;;) {
  606.            if (yyNext (yyState, (yySymbolRange) yyTerminal) == yyNoState) { /* repair */
  607.           yySymbolRange        yyRepairToken;
  608.           tScanAttribute    yyRepairAttribute;
  609.         
  610.           yyRepairToken = yyContinuation [yyState];
  611.           yyState = yyNext (yyState, yyRepairToken);
  612.           if (yyState <= yyLastReadTermState) { /* read or read terminal reduce ? */
  613.              ErrorAttribute ((int) yyRepairToken, & yyRepairAttribute);
  614.              ErrorMessageI (xxTokenInserted, xxRepair, Attribute.Position,
  615.             xxString, Parser_TokenName [yyRepairToken]);
  616.              if (yyState >= yyFirstFinalState) {    /* avoid second push */
  617.             yyState = yyFinalToProd [yyState - yyFirstReadTermState];
  618.              }
  619.              yyGetAttribute (yyAttrStackPtr ++, yyRepairAttribute);
  620.              * ++ yyStateStackPtr = yyState;
  621.           }
  622.           if (yyState >= yyFirstFinalState) goto Final; /* final state ? */
  623.            } else {
  624.           yyState = yyNext (yyState, (yySymbolRange) yyTerminal);
  625.           goto Final;
  626.            }
  627.         }
  628.      }
  629.  
  630.    Final:
  631.      if (yyState >= yyFirstFinalState) {        /* final state ? */
  632.         if (yyState <= yyLastReadTermState) {    /* read terminal reduce ? */
  633.            yyStateStackPtr ++;
  634.            yyGetAttribute (yyAttrStackPtr ++, Attribute);
  635.            yyTerminal = GetToken ();
  636.            yyIsRepairing = false;
  637.         }
  638.  
  639.         for (;;) {
  640.            /* register long yyNonterminal;        /* left-hand side */
  641. # define yyNonterminal yyState
  642.  
  643. switch (yyState) {
  644. case 54: /* _0000_ : spec _EndOfFile .*/
  645.   ReleaseArray ((char * *) & yyStateStack, & yyStateStackSize, sizeof (yyStateRange));
  646.   ReleaseArray ((char * *) & yyAttributeStack, & yyAttrStackSize, sizeof (tParsAttribute));
  647.   return yyErrorCount;
  648.  
  649. case 55:
  650. case 48: /* spec : spec_1 '%%' spec_2 rules spec_3 spec_4 .*/
  651.   yyStateStackPtr -=6; yyAttrStackPtr -=6; yyNonterminal = 26; {
  652.  
  653. } break;
  654. case 56: /* spec_4 : .*/
  655.   yyStateStackPtr -=0; yyAttrStackPtr -=0; yyNonterminal = 25; {
  656.  
  657. } break;
  658. case 57:
  659. case 43: /* spec_4 : '%%' .*/
  660.   yyStateStackPtr -=1; yyAttrStackPtr -=1; yyNonterminal = 25; {
  661.  
  662. } break;
  663. case 58: /* spec_3 : .*/
  664.   yyStateStackPtr -=0; yyAttrStackPtr -=0; yyNonterminal = 24; {
  665. /* line 54 "/tmp/lalr15895" */
  666. /* line 47 "yacc.lalr" */
  667.  yacc_globals (); 
  668. } break;
  669. case 59: /* spec_2 : .*/
  670.   yyStateStackPtr -=0; yyAttrStackPtr -=0; yyNonterminal = 22; {
  671. /* line 56 "/tmp/lalr15895" */
  672. /* line 47 "yacc.lalr" */
  673.  put_text (text_list); 
  674. } break;
  675. case 60: /* spec_1 : .*/
  676.   yyStateStackPtr -=0; yyAttrStackPtr -=0; yyNonterminal = 21; {
  677.  
  678. } break;
  679. case 61:
  680. case 50: /* spec_1 : spec_1 def .*/
  681.   yyStateStackPtr -=2; yyAttrStackPtr -=2; yyNonterminal = 21; {
  682.  
  683. } break;
  684. case 62:
  685. case 38: /* def : '%start' identifier .*/
  686.   yyStateStackPtr -=2; yyAttrStackPtr -=2; yyNonterminal = 27; {
  687. /* line 61 "/tmp/lalr15895" */
  688. /* line 50 "yacc.lalr" */
  689.  start_symbol = yyAttrStackPtr [2-1].Scan.string; 
  690. } break;
  691. case 63:
  692. case 39: /* def : '%union' .*/
  693.   yyStateStackPtr -=1; yyAttrStackPtr -=1; yyNonterminal = 27; {
  694.  
  695. } break;
  696. case 64: /* def : rword tag nlist .*/
  697.   yyStateStackPtr -=3; yyAttrStackPtr -=3; yyNonterminal = 27; {
  698.  
  699. } break;
  700. case 65:
  701. case 36: /* rword : '%token' .*/
  702.   yyStateStackPtr -=1; yyAttrStackPtr -=1; yyNonterminal = 28; {
  703. /* line 66 "/tmp/lalr15895" */
  704. /* line 55 "yacc.lalr" */
  705.  rword = 0; 
  706. } break;
  707. case 66:
  708. case 33: /* rword : '%left' .*/
  709.   yyStateStackPtr -=1; yyAttrStackPtr -=1; yyNonterminal = 28; {
  710. /* line 68 "/tmp/lalr15895" */
  711. /* line 56 "yacc.lalr" */
  712.  rword = 1; put_oper (left_str); 
  713. } break;
  714. case 67:
  715. case 34: /* rword : '%right' .*/
  716.   yyStateStackPtr -=1; yyAttrStackPtr -=1; yyNonterminal = 28; {
  717. /* line 70 "/tmp/lalr15895" */
  718. /* line 57 "yacc.lalr" */
  719.  rword = 1; put_oper (right_str); 
  720. } break;
  721. case 68:
  722. case 35: /* rword : '%nonassoc' .*/
  723.   yyStateStackPtr -=1; yyAttrStackPtr -=1; yyNonterminal = 28; {
  724. /* line 72 "/tmp/lalr15895" */
  725. /* line 58 "yacc.lalr" */
  726.  rword = 1; put_oper (none_str); 
  727. } break;
  728. case 69:
  729. case 37: /* rword : '%type' .*/
  730.   yyStateStackPtr -=1; yyAttrStackPtr -=1; yyNonterminal = 28; {
  731. /* line 74 "/tmp/lalr15895" */
  732. /* line 59 "yacc.lalr" */
  733.  rword = 2; type = 1; 
  734. } break;
  735. case 70:
  736. case 44: /* tag : '<' identifier '>' .*/
  737.   yyStateStackPtr -=3; yyAttrStackPtr -=3; yyNonterminal = 29; {
  738. /* line 77 "/tmp/lalr15895" */
  739. /* line 62 "yacc.lalr" */
  740.  tag = yyAttrStackPtr [2-1].Scan.string; 
  741. } break;
  742. case 71: /* tag : .*/
  743.   yyStateStackPtr -=0; yyAttrStackPtr -=0; yyNonterminal = 29; {
  744. /* line 79 "/tmp/lalr15895" */
  745. /* line 63 "yacc.lalr" */
  746.  tag = 0; 
  747. } break;
  748. case 72:
  749. case 53: /* nlist : nmno .*/
  750.   yyStateStackPtr -=1; yyAttrStackPtr -=1; yyNonterminal = 30; {
  751.  
  752. } break;
  753. case 73:
  754. case 52: /* nlist : nlist nmno .*/
  755.   yyStateStackPtr -=2; yyAttrStackPtr -=2; yyNonterminal = 30; {
  756.  
  757. } break;
  758. case 74:
  759. case 51: /* nlist : nlist ',' nmno .*/
  760.   yyStateStackPtr -=3; yyAttrStackPtr -=3; yyNonterminal = 30; {
  761.  
  762. } break;
  763. case 75: /* nmno : identifier .*/
  764.   yyStateStackPtr -=1; yyAttrStackPtr -=1; yyNonterminal = 31; {
  765. /* line 87 "/tmp/lalr15895" */
  766. /* line 71 "yacc.lalr" */
  767.  switch (rword) {
  768.              case 1 : put_oper (yyAttrStackPtr [1-1].Scan.string);
  769.              case 0 : put_token (yyAttrStackPtr [1-1].Scan.string, 0); break;
  770.              default: break;
  771.                }
  772.                if (tag) put_type (yyAttrStackPtr [1-1].Scan.string, tag); 
  773. } break;
  774. case 76:
  775. case 45: /* nmno : identifier number .*/
  776.   yyStateStackPtr -=2; yyAttrStackPtr -=2; yyNonterminal = 31; {
  777. /* line 96 "/tmp/lalr15895" */
  778. /* line 77 "yacc.lalr" */
  779.  switch (rword) {
  780.                     case 1 : put_oper (yyAttrStackPtr [1-1].Scan.string);
  781.                     case 0 : put_token (yyAttrStackPtr [1-1].Scan.string, yyAttrStackPtr [2-1].Scan.number); break;
  782.                     default: break;
  783.                   }
  784.                   if (tag) put_type (yyAttrStackPtr [1-1].Scan.string, tag); 
  785. } break;
  786. case 77: /* rules : C_IDENT rules_1 ':' rbody prec .*/
  787.   yyStateStackPtr -=5; yyAttrStackPtr -=5; yyNonterminal = 23; {
  788. /* line 106 "/tmp/lalr15895" */
  789. /* line 89 "yacc.lalr" */
  790.  if (has_rhs && ! has_action) put_whole_action (& default_action, true);
  791.         if (prec) { put_delim (prec_str); put_delim (prec); }
  792.         if (yyTerminal != 16) put_delim (dot_str);
  793.         put_rule (rule_elmts_list); put_text (text_list); 
  794. } break;
  795. case 78:
  796. case 49: /* rules : rules rule .*/
  797.   yyStateStackPtr -=2; yyAttrStackPtr -=2; yyNonterminal = 23; {
  798.  
  799. } break;
  800. case 79: /* rules_1 : .*/
  801.   yyStateStackPtr -=0; yyAttrStackPtr -=0; yyNonterminal = 32; {
  802. /* line 114 "/tmp/lalr15895" */
  803. /* line 86 "yacc.lalr" */
  804.  rule_elmts_list = prec = has_rhs = has_action = 0; lhs = yyAttrStackPtr [0-1].Scan.string;
  805.         put_lhs (lhs); put_delim (lhs); put_delim (colon_str); 
  806. } break;
  807. case 80: /* rule : C_IDENT rule_1 ':' rbody prec .*/
  808.   yyStateStackPtr -=5; yyAttrStackPtr -=5; yyNonterminal = 35; {
  809. /* line 120 "/tmp/lalr15895" */
  810. /* line 100 "yacc.lalr" */
  811.  if (has_rhs && ! has_action) put_whole_action (& default_action, true);
  812.         if (prec) { put_delim (prec_str); put_delim (prec); }
  813.         if (yyTerminal != 16) put_delim (dot_str);
  814.         put_rule (rule_elmts_list); put_text (text_list); 
  815. } break;
  816. case 81: /* rule : '|' rule_2 rbody prec .*/
  817.   yyStateStackPtr -=4; yyAttrStackPtr -=4; yyNonterminal = 35; {
  818. /* line 127 "/tmp/lalr15895" */
  819. /* line 108 "yacc.lalr" */
  820.  if (has_rhs && ! has_action) put_whole_action (& default_action, true);
  821.         if (prec) { put_delim (prec_str); put_delim (prec); }
  822.         if (yyTerminal != 16) put_delim (dot_str);
  823.         put_rule (rule_elmts_list); put_text (text_list); 
  824. } break;
  825. case 82: /* rule_2 : .*/
  826.   yyStateStackPtr -=0; yyAttrStackPtr -=0; yyNonterminal = 37; {
  827. /* line 134 "/tmp/lalr15895" */
  828. /* line 105 "yacc.lalr" */
  829.  rule_elmts_list = prec = has_rhs = has_action = 0;
  830.         put_lhs (lhs); put_delim (bar_str); 
  831. } break;
  832. case 83: /* rule_1 : .*/
  833.   yyStateStackPtr -=0; yyAttrStackPtr -=0; yyNonterminal = 36; {
  834. /* line 139 "/tmp/lalr15895" */
  835. /* line 97 "yacc.lalr" */
  836.  rule_elmts_list = prec = has_rhs = has_action = 0; lhs = yyAttrStackPtr [0-1].Scan.string;
  837.         put_lhs (lhs); put_delim (lhs); put_delim (colon_str); 
  838. } break;
  839. case 84:
  840. case 40: /* rbody : rbody identifier .*/
  841.   yyStateStackPtr -=2; yyAttrStackPtr -=2; yyNonterminal = 33; {
  842. /* line 144 "/tmp/lalr15895" */
  843. /* line 114 "yacc.lalr" */
  844.  put_symbol (yyAttrStackPtr [2-1].Scan.string); has_rhs = 1; 
  845. } break;
  846. case 85:
  847. case 47: /* rbody : rbody act .*/
  848.   yyStateStackPtr -=2; yyAttrStackPtr -=2; yyNonterminal = 33; {
  849.  
  850. } break;
  851. case 86: /* rbody : .*/
  852.   yyStateStackPtr -=0; yyAttrStackPtr -=0; yyNonterminal = 33; {
  853.  
  854. } break;
  855. case 87:
  856. case 41: /* act : '{' '}' .*/
  857.   yyStateStackPtr -=2; yyAttrStackPtr -=2; yyNonterminal = 38; {
  858. /* line 151 "/tmp/lalr15895" */
  859. /* line 121 "yacc.lalr" */
  860.  has_action = 1; put_whole_action (yyAttrStackPtr [2-1].Scan.action, has_rhs &
  861.             /* is it last action ? */
  862.             (yyTerminal == 16 || yyTerminal == 19 || yyTerminal == 0)); 
  863. } break;
  864. case 88: /* prec : '%prec' identifier .*/
  865.   yyStateStackPtr -=2; yyAttrStackPtr -=2; yyNonterminal = 34; {
  866. /* line 157 "/tmp/lalr15895" */
  867. /* line 126 "yacc.lalr" */
  868.  prec = yyAttrStackPtr [2-1].Scan.string; 
  869. } break;
  870. case 89:
  871. case 46: /* prec : '%prec' identifier act .*/
  872.   yyStateStackPtr -=3; yyAttrStackPtr -=3; yyNonterminal = 34; {
  873. /* line 159 "/tmp/lalr15895" */
  874. /* line 127 "yacc.lalr" */
  875.  prec = yyAttrStackPtr [2-1].Scan.string; 
  876. } break;
  877. case 90:
  878. case 42: /* prec : prec ';' .*/
  879.   yyStateStackPtr -=2; yyAttrStackPtr -=2; yyNonterminal = 34; {
  880.  
  881. } break;
  882. case 91: /* prec : .*/
  883.   yyStateStackPtr -=0; yyAttrStackPtr -=0; yyNonterminal = 34; {
  884.  
  885. } break;
  886. }
  887.  
  888.            /* SPEC State = Next (Top (), Nonterminal); nonterminal transition */
  889.            yyState = * (yyNBasePtr [* yyStateStackPtr ++] + yyNonterminal);
  890.            * yyAttrStackPtr ++ = yySynAttribute;
  891.            if (yyState < yyFirstFinalState) goto ParseLoop; /* read nonterminal reduce ? */
  892.         } 
  893.  
  894.      } else {                    /* read */
  895.         yyStateStackPtr ++;
  896.         yyGetAttribute (yyAttrStackPtr ++, Attribute);
  897.         yyTerminal = GetToken ();
  898.         yyIsRepairing = false;
  899.      }
  900.       }
  901.    }
  902.  
  903. static void yyErrorRecovery
  904. # if defined __STDC__ | defined __cplusplus
  905.    (yySymbolRange * yyTerminal, yyStateRange * yyStateStack, unsigned long yyStackSize, short yyStackPtr)
  906. # else
  907.    (yyTerminal, yyStateStack, yyStackSize, yyStackPtr)
  908.    yySymbolRange *    yyTerminal    ;
  909.    yyStateRange *    yyStateStack    ;
  910.    unsigned long    yyStackSize    ;
  911.    short        yyStackPtr    ;
  912. # endif
  913.    {
  914.       bool    yyTokensSkipped    ;
  915.       tSet    yyContinueSet    ;
  916.       tSet    yyRestartSet    ;
  917.       int    yyLength = 0    ;
  918.       char    yyContinueString [256];
  919.  
  920.    /* 1. report an error */
  921.       ErrorMessage (xxSyntaxError, xxError, Attribute.Position);
  922.  
  923.    /* 2. report the set of expected terminal symbols */
  924.       MakeSet (& yyContinueSet, (short) yyLastTerminal);
  925.       yyComputeContinuation (yyStateStack, yyStackSize, yyStackPtr, & yyContinueSet);
  926.       yyContinueString [0] = '\0';
  927.       while (! IsEmpty (& yyContinueSet)) {
  928.      char * yyTokenString = Parser_TokenName [Extract (& yyContinueSet)];
  929.      if ((yyLength += strlen (yyTokenString) + 1) >= 256) break;
  930.      (void) strcat (yyContinueString, yyTokenString);
  931.      (void) strcat (yyContinueString, " ");
  932.       }
  933.       ErrorMessageI (xxExpectedTokens, xxInformation, Attribute.Position,
  934.      xxString, yyContinueString);
  935.       ReleaseSet (& yyContinueSet);
  936.  
  937.    /* 3. compute the set of terminal symbols for restart of the parse */
  938.       MakeSet (& yyRestartSet, (short) yyLastTerminal);
  939.       yyComputeRestartPoints (yyStateStack, yyStackSize, yyStackPtr, & yyRestartSet);
  940.  
  941.    /* 4. skip terminal symbols until a restart point is reached */
  942.       yyTokensSkipped = false;
  943.       while (! IsElement (* yyTerminal, & yyRestartSet)) {
  944.      * yyTerminal = GetToken ();
  945.      yyTokensSkipped = true;
  946.       }
  947.       ReleaseSet (& yyRestartSet);
  948.  
  949.    /* 5. report the restart point */
  950.       if (yyTokensSkipped) {
  951.      ErrorMessage (xxRestartPoint, xxInformation, Attribute.Position);
  952.       }
  953.    }
  954.  
  955. /*
  956.    compute the set of terminal symbols that can be accepted (read)
  957.    in a given stack configuration (eventually after reduce actions)
  958. */
  959.  
  960. static void yyComputeContinuation
  961. # if defined __STDC__ | defined __cplusplus
  962.    (yyStateRange * yyStack, unsigned long yyStackSize, short yyStackPtr, tSet * yyContinueSet)
  963. # else
  964.    (yyStack, yyStackSize, yyStackPtr, yyContinueSet)
  965.    yyStateRange *    yyStack        ;
  966.    unsigned long    yyStackSize    ;
  967.    short        yyStackPtr    ;
  968.    tSet *        yyContinueSet    ;
  969. # endif
  970.    {
  971.       register yySymbolRange    yyTerminal;
  972.       register yyStateRange    yyState = yyStack [yyStackPtr];
  973.  
  974.       AssignEmpty (yyContinueSet);
  975.       for (yyTerminal = yyFirstTerminal; yyTerminal <= yyLastTerminal; yyTerminal ++) {
  976.      if (yyNext (yyState, yyTerminal) != yyNoState &&
  977.         yyIsContinuation (yyTerminal, yyStack, yyStackSize, yyStackPtr)) {
  978.         Include (yyContinueSet, (short) yyTerminal);
  979.      }
  980.       }
  981.    }
  982.  
  983. /*
  984.    check whether a given terminal symbol can be accepted (read)
  985.    in a certain stack configuration (eventually after reduce actions)
  986. */
  987.  
  988. static bool yyIsContinuation
  989. # if defined __STDC__ | defined __cplusplus
  990.    (yySymbolRange yyTerminal, yyStateRange * yyStateStack, unsigned long yyStackSize, short yyStackPtr)
  991. # else
  992.    (yyTerminal, yyStateStack, yyStackSize, yyStackPtr)
  993.    yySymbolRange    yyTerminal    ;
  994.    yyStateRange *    yyStateStack    ;
  995.    unsigned long    yyStackSize    ;
  996.    short        yyStackPtr    ;
  997. # endif
  998.    {
  999.       register yyStateRange    yState        ;
  1000.       register yySymbolRange    yyNonterminal    ;
  1001.            yyStateRange *    yyStack        ;
  1002.    
  1003.       MakeArray ((char * *) & yyStack, & yyStackSize, sizeof (yyStateRange));    /* pass Stack by value */
  1004. # ifdef BCOPY
  1005.       bcopy ((char *) yyStateStack, (char *) yyStack, (int) sizeof (yyStateRange) * (yyStackPtr + 1));
  1006. # else
  1007.       (void) memcpy ((char *) yyStack, (char *) yyStateStack, (int) sizeof (yyStateRange) * (yyStackPtr + 1));
  1008. # endif
  1009.  
  1010.       yState = yyStack [yyStackPtr];
  1011.       for (;;) {
  1012.      yyStack [yyStackPtr] = yState;
  1013.      yState = yyNext (yState, yyTerminal);
  1014.      if (yState == yyNoState) {
  1015.         ReleaseArray ((char * *) & yyStack, & yyStackSize, sizeof (yyStateRange));
  1016.         return false;
  1017.      }
  1018.      if (yState <= yyLastReadTermState) {        /* read or read terminal reduce ? */
  1019.         ReleaseArray ((char * *) & yyStack, & yyStackSize, sizeof (yyStateRange));
  1020.         return true;
  1021.      }
  1022.  
  1023.      for (;;) {                    /* reduce */
  1024.         if (yState == yyStopState) {
  1025.            ReleaseArray ((char * *) & yyStack, & yyStackSize, sizeof (yyStateRange));
  1026.            return true;
  1027.         } else { 
  1028.            yyStackPtr -= yyLength [yState - yyFirstReduceState];
  1029.            yyNonterminal = yyLeftHandSide [yState - yyFirstReduceState];
  1030.         }
  1031.  
  1032.         yState = yyNext (yyStack [yyStackPtr], yyNonterminal);
  1033.         if (yyStackPtr >= yyStackSize) {
  1034.            ExtendArray ((char * *) & yyStack, & yyStackSize, sizeof (yyStateRange));
  1035.         }
  1036.         yyStackPtr ++;
  1037.         if (yState < yyFirstFinalState) break;    /* read nonterminal ? */
  1038.         yState = yyFinalToProd [yState - yyFirstReadTermState];    /* read nonterminal reduce */
  1039.      }
  1040.       }
  1041.    }
  1042.  
  1043. /*
  1044.    compute a set of terminal symbols that can be used to restart
  1045.    parsing in a given stack configuration. we simulate parsing until
  1046.    end of file using a suffix program synthesized by the function
  1047.    Continuation. All symbols acceptable in the states reached during
  1048.    the simulation can be used to restart parsing.
  1049. */
  1050.  
  1051. static void yyComputeRestartPoints
  1052. # if defined __STDC__ | defined __cplusplus
  1053.    (yyStateRange * yyStateStack, unsigned long yyStackSize, short yyStackPtr, tSet * yyRestartSet)
  1054. # else
  1055.    (yyStateStack, yyStackSize, yyStackPtr, yyRestartSet)
  1056.    yyStateRange *    yyStateStack    ;
  1057.    unsigned long    yyStackSize    ;
  1058.    short        yyStackPtr    ;
  1059.    tSet *        yyRestartSet    ;
  1060. # endif
  1061.    {
  1062.       register yyStateRange    yState        ;
  1063.       register yySymbolRange    yyNonterminal    ;
  1064.            yyStateRange *    yyStack        ;
  1065.            tSet        yyContinueSet    ;
  1066.    
  1067.       MakeArray ((char * *) & yyStack, & yyStackSize, sizeof (yyStateRange)); /* pass Stack by value */
  1068. # ifdef BCOPY
  1069.       bcopy ((char *) yyStateStack, (char *) yyStack, (int) sizeof (yyStateRange) * (yyStackPtr + 1));
  1070. # else
  1071.       (void) memcpy ((char *) yyStack, (char *) yyStateStack, (int) sizeof (yyStateRange) * (yyStackPtr + 1));
  1072. # endif
  1073.  
  1074.       MakeSet (& yyContinueSet, (short) yyLastTerminal);
  1075.       AssignEmpty (yyRestartSet);
  1076.       yState = yyStack [yyStackPtr];
  1077.  
  1078.       for (;;) {
  1079.      if (yyStackPtr >= yyStackSize) {
  1080.         ExtendArray ((char * *) & yyStack, & yyStackSize, sizeof (yyStateRange));
  1081.      }
  1082.      yyStack [yyStackPtr] = yState;
  1083.      yyComputeContinuation (yyStack, yyStackSize, yyStackPtr, & yyContinueSet);
  1084.      Union (yyRestartSet, & yyContinueSet);
  1085.      yState = yyNext (yState, yyContinuation [yState]);
  1086.  
  1087.      if (yState >= yyFirstFinalState) {        /* final state ? */
  1088.         if (yState <= yyLastReadTermState) {    /* read terminal reduce ? */
  1089.            yyStackPtr ++;
  1090.            yState = yyFinalToProd [yState - yyFirstReadTermState];
  1091.         }
  1092.  
  1093.         for (;;) {                    /* reduce */
  1094.            if (yState == yyStopState) {
  1095.           ReleaseSet (& yyContinueSet);
  1096.           ReleaseArray ((char * *) & yyStack, & yyStackSize, sizeof (yyStateRange));
  1097.           return;
  1098.            } else { 
  1099.           yyStackPtr -= yyLength [yState - yyFirstReduceState];
  1100.           yyNonterminal = yyLeftHandSide [yState - yyFirstReduceState];
  1101.            }
  1102.  
  1103.            yState = yyNext (yyStack [yyStackPtr], yyNonterminal);
  1104.            yyStackPtr ++;
  1105.            if (yState < yyFirstFinalState) break;    /* read nonterminal ? */
  1106.            yState = yyFinalToProd [yState - yyFirstReadTermState]; /* read nonterminal reduce */
  1107.         }
  1108.      } else {                    /* read */
  1109.         yyStackPtr ++;
  1110.      }
  1111.       }
  1112.    }
  1113.  
  1114. /* access the parse table:   Next : State x Symbol -> Action */
  1115.  
  1116. static yyStateRange yyNext
  1117. # if defined __STDC__ | defined __cplusplus
  1118.    (yyStateRange yyState, yySymbolRange yySymbol)
  1119. # else
  1120.    (yyState, yySymbol) yyStateRange yyState; yySymbolRange yySymbol;
  1121. # endif
  1122.    {
  1123.       register yyTCombType * yyTCombPtr;
  1124.  
  1125.       if (yySymbol <= yyLastTerminal) {
  1126.      for (;;) {
  1127.         yyTCombPtr = yyTBasePtr [yyState] + yySymbol;
  1128.         if (yyTCombPtr->Check != yyState) {
  1129.            if ((yyState = yyDefault [yyState]) == yyNoState) return yyNoState;
  1130.         } else {
  1131.            return yyTCombPtr->Next;
  1132.         }
  1133.      }
  1134.       } else {
  1135.     return * (yyNBasePtr [yyState] + yySymbol);
  1136.       }
  1137.    }
  1138.  
  1139. static void BeginParser ()
  1140.    {
  1141. /* line 23 "/tmp/lalr15895" */
  1142. /* line 19 "yacc.lalr" */
  1143.  
  1144. left_str    = PutString ("\n\tLEFT", 6);
  1145. right_str    = PutString ("\n\tRIGHT", 7);
  1146. none_str    = PutString ("\n\tNONE", 6);
  1147. colon_str    = PutString ("\t:", 2);
  1148. bar_str        = PutString ("\t|", 2);
  1149. action_str    = PutString (" }}", 3);
  1150. prec_str    = PutString ("PREC", 4);
  1151. dot_str        = PutString ("\n\t.", 3);
  1152. default_action.car = action_str;
  1153.  
  1154.    }
  1155.  
  1156. void CloseParser ()
  1157.    {
  1158.  
  1159.    }
  1160.